home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 3 / CD ACTUAL 3.iso / linux / system / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / src / Framework / Event.cxx < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-26  |  4.2 KB  |  168 lines
  1. ///////////////////////////////////////////////////////////////////////////////
  2. // $Id: Event.cxx,v 1.1 1994/02/18 19:49:38 bmott Exp $
  3. ///////////////////////////////////////////////////////////////////////////////
  4. //
  5. // Event.cxx
  6. //
  7. //   This class maintains a queue of events requested by EventBase derived
  8. // objects.
  9. //
  10. //
  11. // BSVC "A Microprocessor Simulation Framework"
  12. // Copyright (c) 1993
  13. // By: Bradford W. Mott
  14. // August 11,1993
  15. //
  16. ///////////////////////////////////////////////////////////////////////////////
  17. // $Log: Event.cxx,v $
  18. // Revision 1.1  1994/02/18  19:49:38  bmott
  19. // Initial revision
  20. //
  21. ///////////////////////////////////////////////////////////////////////////////
  22.  
  23. #include "Event.hxx"
  24. #include "Time.hxx"
  25.  
  26. ///////////////////////////////////////////////////////////////////////////////
  27. // EventBase Destructor
  28. ///////////////////////////////////////////////////////////////////////////////
  29. EventBase::~EventBase()
  30. { 
  31.   // Remove any events in the EventHandler for this object
  32.   event_handler->Remove(this);
  33. }
  34.  
  35. ///////////////////////////////////////////////////////////////////////////////
  36. // EventHandler Constructor
  37. ///////////////////////////////////////////////////////////////////////////////
  38. EventHandler::EventHandler()
  39.     : list((void *)0),
  40.       iterations(0),
  41.       usec_per_check(20)
  42. {
  43.   Time time;
  44.  
  45.   old_time=time.seconds();
  46. }
  47.  
  48.  
  49. ///////////////////////////////////////////////////////////////////////////////
  50. // Check for any expired events
  51. ///////////////////////////////////////////////////////////////////////////////
  52. void EventHandler::Check()
  53. {
  54.   long new_time;
  55.   Time time;                         
  56.  
  57.   ++iterations;                      // This is another iteration
  58.   new_time=time.seconds();           // Get the current time in seconds
  59.  
  60.   // Check to see if it's time to update usec_per_check
  61.   if(new_time!=old_time)
  62.   {
  63.     usec_per_check=((new_time-old_time)*1000000)/iterations;
  64.     old_time=new_time;
  65.     iterations=0;
  66.   }
  67.  
  68.   // If the list isn't empty    
  69.   if(list != (void *)0)
  70.   {
  71.     // Decrement delta_time of the earliest event
  72.     if((list->delta_time -= usec_per_check) <= 0)
  73.     {
  74.       Event *tmp=list;
  75.  
  76.       list=list->next;
  77.       if(list != (void *)0)
  78.         list->delta_time += tmp->delta_time;  // In case of some overrun
  79.  
  80.       // This has to be done last because the callback might Add new events :-)
  81.       tmp->Dispatch();
  82.       delete tmp;
  83.     }
  84.   }
  85. }
  86.  
  87. ///////////////////////////////////////////////////////////////////////////////
  88. // Add an event to the event list
  89. ///////////////////////////////////////////////////////////////////////////////
  90. void EventHandler::Add(EventBase *object, long data, void* pointer, long time)
  91. {
  92.   Event *event=new Event(object,data,pointer,time);
  93.  
  94.   if(list == (void *)0)
  95.   {
  96.     list=event;
  97.     event->delta_time=time;
  98.   }
  99.   else if(time < list->delta_time)
  100.   {
  101.     event->next = list;
  102.     event->delta_time = time;
  103.     list->delta_time -= time;
  104.     list = event;
  105.   }
  106.   else
  107.   {
  108.     Event *p=list;
  109.     long tmp_delta = list->delta_time;
  110.  
  111.     while(p->next != (void *)0)
  112.     {
  113.       if(time < (tmp_delta + p->next->delta_time) )
  114.       {
  115.         event->delta_time = time-tmp_delta;
  116.         p->next->delta_time -= event->delta_time;
  117.         event->next = p->next;
  118.         p->next = event;
  119.         break;
  120.       }
  121.       else
  122.       {
  123.         p=p->next;
  124.         tmp_delta += p->delta_time;
  125.       }
  126.     }
  127.  
  128.     if(p->next == (void *)0)
  129.     {
  130.       p->next = event;
  131.       event->delta_time = time-tmp_delta;
  132.     }
  133.   } 
  134. } 
  135.  
  136. ///////////////////////////////////////////////////////////////////////////////
  137. // Remove events for the given object
  138. ///////////////////////////////////////////////////////////////////////////////
  139. void EventHandler::Remove(EventBase* object)
  140. {
  141.   Event *p,*q;
  142.   int done=0;
  143.  
  144.   // Keep looping until no events are deleted
  145.   while(!done)
  146.   {
  147.     done=1;
  148.  
  149.     // Loop through all of the events removing the first one for this object
  150.     for(q=(Event*)0,p=list;p!=(Event*)0;q=p,p=p->next)
  151.     {
  152.       // Check to see if it belongs to object
  153.       if(p->Owner() == object)
  154.       {
  155.         // Delete the event from the event list
  156.         if(q == (Event*)0) 
  157.           list=list->next;
  158.         else
  159.           q->next=p->next;
  160.         delete p;
  161.         done=0;
  162.         break;
  163.       }
  164.     }
  165.   }
  166. }
  167.  
  168.